home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / umich / network / ka9q / nhclb120.zoo / nrs.c < prev    next >
C/C++ Source or Header  |  1992-06-18  |  6KB  |  264 lines
  1. /* This module implements the serial line framing method used by
  2.  * net/rom nodes.  This allows the net/rom software to talk to
  3.  * an actual net/rom over its serial interface, which is useful
  4.  * if we want to do packet switching for multi-line wormholes.
  5.  * Dan Frank, W9NK
  6.  */
  7. #include <stdio.h>
  8. #include "global.h"
  9. #include "mbuf.h"
  10. #include "iface.h"
  11. #include "ax25.h"
  12. #include "nrs.h"
  13. #include "asy.h"
  14. #include "trace.h"
  15.  
  16. int asy_output();
  17. static nrsq();
  18. static nrasy_start();
  19. static struct mbuf *nrs_encode();
  20.  
  21.  
  22. /* control structures, sort of overlayed on async control blocks */
  23. struct nrs nrs[ASY_MAX];
  24.  
  25. /* Send a raw net/rom serial frame */
  26. nrs_raw(interface,bp)
  27. struct interface *interface;
  28. struct mbuf *bp;
  29. {
  30.     dump(interface,IF_TRACE_OUT,TRACE_AX25,bp) ;
  31.     
  32.     /* Queue a frame on the output queue and start transmitter */
  33.     nrsq(interface->dev,bp);
  34. }
  35.  
  36. /* Encode a raw packet in net/rom framing, put on link output queue, and kick
  37.  * transmitter
  38.  */
  39. static
  40. nrsq(dev,bp)
  41. int16 dev;        /* Serial line number */
  42. struct mbuf *bp;    /* Buffer to be sent */
  43. {
  44.     register struct nrs *sp;
  45.     struct mbuf *nrs_encode();
  46.  
  47.     if((bp = nrs_encode(bp)) == NULLBUF)
  48.         return;    
  49.  
  50.     sp = &nrs[dev];
  51.     enqueue(&sp->sndq,bp);
  52.     sp->sndcnt++;
  53.     if(sp->tbp == NULLBUF)
  54.         nrasy_start(dev);
  55. }
  56.  
  57. /* Start output, if possible, on asynch device dev */
  58. static
  59. nrasy_start(dev)
  60. int16 dev;
  61. {
  62.     register struct nrs *sp;
  63.  
  64.     if(!stxrdy(dev))
  65.         return;        /* Transmitter not ready */
  66.  
  67.     sp = &nrs[dev];
  68.     if(sp->tbp != NULLBUF){
  69.         /* transmission just completed */
  70.         free_p(sp->tbp);
  71.         sp->tbp = NULLBUF;
  72.     }
  73.     if(sp->sndq == NULLBUF)
  74.         return;    /* No work */
  75.  
  76.     sp->tbp = dequeue(&sp->sndq);
  77.     sp->sndcnt--;
  78.     asy_output(dev,sp->tbp->data,sp->tbp->cnt);
  79. }
  80.  
  81. /* Encode a packet in net/rom serial format */
  82. static
  83. struct mbuf *
  84. nrs_encode(bp)
  85. struct mbuf *bp;
  86. {
  87.     struct mbuf *lbp;    /* Mbuf containing line-ready packet */
  88.     register char *cp;
  89.     char c;
  90.     unsigned char csum = 0 ;
  91.  
  92.     /* Allocate output mbuf that's twice as long as the packet.
  93.      * This is a worst-case guess (consider a packet full of STX's!)
  94.      * Add five bytes for STX, ETX, checksum, and two nulls.
  95.      */
  96.     lbp = alloc_mbuf(2*len_mbuf(bp) + 5);
  97.     if(lbp == NULLBUF){
  98.         /* No space; drop */
  99.         free_p(bp);
  100.         return NULLBUF;
  101.     }
  102.     cp = lbp->data;
  103.  
  104.     *cp++ = STX ;
  105.  
  106.     /* Copy input to output, escaping special characters */
  107.     while(pullup(&bp,&c,1) == 1){
  108.         switch(uchar(c)){
  109.         case STX:
  110.         case ETX:
  111.         case DLE:
  112.             *cp++ = DLE;
  113.             /* notice drop through to default */
  114.         default:
  115.             *cp++ = c;
  116.         }
  117.         csum += uchar(c) ;
  118.     }
  119.     *cp++ = ETX;
  120.     *cp++ = csum ;
  121.     *cp++ = NUL ;
  122.     *cp++ = NUL ;
  123.     
  124.     lbp->cnt = cp - lbp->data;
  125.     return lbp;
  126. }
  127. /* Process incoming bytes in net/rom serial format
  128.  * When a buffer is complete, return it; otherwise NULLBUF
  129.  */
  130. static
  131. struct mbuf *
  132. nrs_decode(dev,c)
  133. int16 dev;    /* net/rom unit number */
  134. char c;        /* Incoming character */
  135. {
  136.     struct mbuf *bp;
  137.     register struct nrs *sp;
  138.  
  139.     sp = &nrs[dev];
  140.     switch(sp->state) {
  141.         case NRS_INTER:
  142.             if (uchar(c) == STX) {    /* look for start of frame */
  143.                 sp->state = NRS_INPACK ;    /* we're in a packet */
  144.                 sp->csum = 0 ;                /* reset checksum */
  145.             }
  146.             return NULLBUF ;
  147.             break ;    /* just for yucks */
  148.         case NRS_CSUM:
  149.             bp = sp->rbp ;
  150.             sp->rbp = NULLBUF ;
  151.             sp->rcnt = 0 ;
  152.             sp->state = NRS_INTER ;    /* go back to inter-packet state */
  153.             if (sp->csum == uchar(c)) {
  154.                 sp->packets++ ;
  155.                 return bp ;
  156.             }
  157.             else {
  158.                 free_p(bp) ;    /* drop packet with bad checksum */
  159.                 sp->errors++ ;    /* increment error count */
  160.                 return NULLBUF ;
  161.             }
  162.             break ;
  163.         case NRS_ESCAPE:
  164.             sp->state = NRS_INPACK ;    /* end of escape */
  165.             break ;            /* this will drop through to char processing */
  166.         case NRS_INPACK:
  167.             switch (uchar(c)) {
  168.                 /* If we see an STX in a packet, assume that previous */
  169.                 /* packet was trashed, and start a new packet */
  170.                 case STX:
  171.                     free_p(sp->rbp) ;
  172.                     sp->rbp = NULLBUF ;
  173.                     sp->rcnt = 0 ;
  174.                     sp->csum = 0 ;
  175.                     sp->errors++ ;
  176.                     return NULLBUF ;
  177.                     break ;
  178.                 case ETX:
  179.                     sp->state = NRS_CSUM ;    /* look for checksum */
  180.                     return NULLBUF ;
  181.                     break ;
  182.                 case DLE:
  183.                     sp->state = NRS_ESCAPE ;
  184.                     return NULLBUF ;
  185.                     break ;
  186.             }
  187.     }
  188.     /* If we get to here, it's with a character that's part of the packet.
  189.      * Make sure there's space for it.
  190.      */
  191.     if(sp->rbp == NULLBUF){
  192.         /* Allocate first mbuf for new packet */
  193.         if((sp->rbp1 = sp->rbp = alloc_mbuf(NRS_ALLOC)) == NULLBUF) {
  194.             sp->state = NRS_INTER ;
  195.             return NULLBUF; /* No memory, drop */
  196.         }
  197.         sp->rcp = sp->rbp->data;
  198.     } else if(sp->rbp1->cnt == NRS_ALLOC){
  199.         /* Current mbuf is full; link in another */
  200.         if((sp->rbp1->next = alloc_mbuf(NRS_ALLOC)) == NULLBUF){
  201.             /* No memory, drop whole thing */
  202.             free_p(sp->rbp);
  203.             sp->rbp = NULLBUF;
  204.             sp->rcnt = 0;
  205.             sp->state = NRS_INTER ;
  206.             return NULLBUF;
  207.         }
  208.         sp->rbp1 = sp->rbp1->next;
  209.         sp->rcp = sp->rbp1->data;
  210.     }
  211.     /* Store the character, increment fragment and total
  212.      * byte counts
  213.      */
  214.     *sp->rcp++ = c;
  215.     sp->rbp1->cnt++;
  216.     sp->rcnt++;
  217.     sp->csum += uchar(c) ;    /* add to checksum */
  218.     return NULLBUF;
  219. }
  220.  
  221. /* Process net/rom serial line I/O */
  222. void
  223. nrs_recv(interface)
  224. struct interface *interface;
  225. {
  226.     char c;
  227.     struct mbuf *bp;
  228.     int16 dev;
  229.     int16 asy_recv();
  230.     int ax_recv() ;
  231.  
  232.     dev = interface->dev;
  233.     /* Process any pending input */
  234.     while(asy_recv(dev,&c,1) != 0)
  235.         if((bp = nrs_decode(dev,c)) != NULLBUF) {
  236.             dump(interface,IF_TRACE_IN,TRACE_AX25,bp) ;
  237.             ax_recv(interface,bp);
  238.         }
  239.  
  240.     /* Kick the transmitter if it's idle */
  241.     if(stxrdy(dev))
  242.         nrasy_start(dev);
  243. }
  244.  
  245. /* donrstat:  display status of active net/rom serial interfaces */
  246. /*ARGSUSED*/
  247. donrstat(argc,argv)
  248. int argc ;
  249. char *argv[] ;
  250. {
  251.     register struct nrs *np ;
  252.     register int i ;
  253.  
  254.     printf("Interface  SndQ  RcvB  NumReceived  CSumErrors\n") ;
  255.  
  256.     for (i = 0, np = nrs ; i < ASY_MAX ; i++, np++)
  257.         if (np->iface != NULLIF)
  258.             printf(" %8s   %3d  %4d   %10lu  %10lu\n",
  259.                     np->iface->name, np->sndcnt, np->rcnt,
  260.                     np->packets, np->errors) ;
  261.  
  262.     return 0 ;
  263. }
  264.